* SPDX-License-Identifier: BSD-3-Clause
*/
-#ifndef __BAKERY_LOCK_H__
-#define __BAKERY_LOCK_H__
+#ifndef BAKERY_LOCK_H
+#define BAKERY_LOCK_H
#include <platform_def.h>
#ifndef __ASSEMBLY__
#include <cdefs.h>
+#include <stdbool.h>
#include <stdint.h>
+#include <utils_def.h>
/*****************************************************************************
- * Internal helper macros used by the bakery lock implementation.
+ * Internal helpers used by the bakery lock implementation.
****************************************************************************/
+
/* Convert a ticket to priority */
-#define PRIORITY(t, pos) (((t) << 8) | (pos))
+static inline unsigned int bakery_get_priority(unsigned int t, unsigned int pos)
+{
+ return (t << 8) | pos;
+}
+
+#define CHOOSING_TICKET U(0x1)
+#define CHOSEN_TICKET U(0x0)
+
+static inline bool bakery_is_choosing(unsigned int info)
+{
+ return (info & 1U) == CHOOSING_TICKET;
+}
+
+static inline unsigned int bakery_ticket_number(unsigned int info)
+{
+ return (info >> 1) & 0x7FFFU;
+}
-#define CHOOSING_TICKET 0x1
-#define CHOSEN_TICKET 0x0
+static inline uint16_t make_bakery_data(unsigned int choosing, unsigned int num)
+{
+ unsigned int val = (choosing & 0x1U) | (num << 1);
-#define bakery_is_choosing(info) (info & 0x1)
-#define bakery_ticket_number(info) ((info >> 1) & 0x7FFF)
-#define make_bakery_data(choosing, number) \
- (((choosing & 0x1) | (number << 1)) & 0xFFFF)
+ return (uint16_t) val;
+}
/*****************************************************************************
* External bakery lock interface.
#endif /* __ASSEMBLY__ */
-#endif /* __BAKERY_LOCK_H__ */
+#endif /* BAKERY_LOCK_H */
*/
#define assert_bakery_entry_valid(_entry, _bakery) do { \
- assert(_bakery); \
- assert(_entry < BAKERY_LOCK_MAX_CPUS); \
-} while (0)
+ assert((_bakery) != NULL); \
+ assert((_entry) < BAKERY_LOCK_MAX_CPUS); \
+} while (false)
/* Obtain a ticket for a given CPU */
static unsigned int bakery_get_ticket(bakery_lock_t *bakery, unsigned int me)
unsigned int they;
/* Prevent recursive acquisition */
- assert(!bakery_ticket_number(bakery->lock_data[me]));
+ assert(bakery_ticket_number(bakery->lock_data[me]) == 0U);
/*
* Flag that we're busy getting our ticket. All CPUs are iterated in the
* ticket value. That's OK as the lock is acquired based on the priority
* value, not the ticket value alone.
*/
- my_ticket = 0;
+ my_ticket = 0U;
bakery->lock_data[me] = make_bakery_data(CHOOSING_TICKET, my_ticket);
- for (they = 0; they < BAKERY_LOCK_MAX_CPUS; they++) {
+ for (they = 0U; they < BAKERY_LOCK_MAX_CPUS; they++) {
their_ticket = bakery_ticket_number(bakery->lock_data[they]);
if (their_ticket > my_ticket)
my_ticket = their_ticket;
* Now that we got our ticket, compute our priority value, then compare
* with that of others, and proceed to acquire the lock
*/
- my_prio = PRIORITY(my_ticket, me);
- for (they = 0; they < BAKERY_LOCK_MAX_CPUS; they++) {
+ my_prio = bakery_get_priority(my_ticket, me);
+ for (they = 0U; they < BAKERY_LOCK_MAX_CPUS; they++) {
if (me == they)
continue;
* (valid) ticket value. If they do, compare priorities
*/
their_ticket = bakery_ticket_number(their_bakery_data);
- if (their_ticket && (PRIORITY(their_ticket, they) < my_prio)) {
+ if ((their_ticket != 0U) &&
+ (bakery_get_priority(their_ticket, they) < my_prio)) {
/*
* They have higher priority (lower value). Wait for
* their ticket value to change (either release the lock
unsigned int me = plat_my_core_pos();
assert_bakery_entry_valid(me, bakery);
- assert(bakery_ticket_number(bakery->lock_data[me]));
+ assert(bakery_ticket_number(bakery->lock_data[me]) != 0U);
/*
* Ensure that other observers see any stores in the critical section
* Then signal other waiting contenders.
*/
dmbst();
- bakery->lock_data[me] = 0;
+ bakery->lock_data[me] = 0U;
dsb();
sev();
}
IMPORT_SYM(uintptr_t, __PERCPU_BAKERY_LOCK_SIZE__, PERCPU_BAKERY_LOCK_SIZE);
#endif
-#define get_bakery_info(_cpu_ix, _lock) \
- (bakery_info_t *)((uintptr_t)_lock + _cpu_ix * PERCPU_BAKERY_LOCK_SIZE)
+static inline bakery_lock_t *get_bakery_info(unsigned int cpu_ix,
+ bakery_lock_t *lock)
+{
+ return (bakery_info_t *)((uintptr_t)lock +
+ cpu_ix * PERCPU_BAKERY_LOCK_SIZE);
+}
-#define write_cache_op(_addr, _cached) \
- do { \
- (_cached ? dccvac((uintptr_t)_addr) :\
- dcivac((uintptr_t)_addr));\
- dsbish();\
- } while (0)
+static inline void write_cache_op(uintptr_t addr, bool cached)
+{
+ if (cached)
+ dccvac(addr);
+ else
+ dcivac(addr);
-#define read_cache_op(_addr, _cached) if (_cached) \
- dccivac((uintptr_t)_addr)
+ dsbish();
+}
+
+static inline void read_cache_op(uintptr_t addr, bool cached)
+{
+ if (cached)
+ dccivac(addr);
+}
/* Helper function to check if the lock is acquired */
-static inline int is_lock_acquired(const bakery_info_t *my_bakery_info,
+static inline bool is_lock_acquired(const bakery_info_t *my_bakery_info,
int is_cached)
{
/*
* operations were not propagated to all the caches in the system.
* Hence do a `read_cache_op()` prior to read.
*/
- read_cache_op(my_bakery_info, is_cached);
- return !!(bakery_ticket_number(my_bakery_info->lock_data));
+ read_cache_op((uintptr_t)my_bakery_info, is_cached);
+ return bakery_ticket_number(my_bakery_info->lock_data) != 0U;
}
static unsigned int bakery_get_ticket(bakery_lock_t *lock,
* it is not NULL.
*/
my_bakery_info = get_bakery_info(me, lock);
- assert(my_bakery_info);
+ assert(my_bakery_info != NULL);
/* Prevent recursive acquisition.*/
assert(!is_lock_acquired(my_bakery_info, is_cached));
* Tell other contenders that we are through the bakery doorway i.e.
* going to allocate a ticket for this cpu.
*/
- my_ticket = 0;
+ my_ticket = 0U;
my_bakery_info->lock_data = make_bakery_data(CHOOSING_TICKET, my_ticket);
- write_cache_op(my_bakery_info, is_cached);
+ write_cache_op((uintptr_t)my_bakery_info, is_cached);
/*
* Iterate through the bakery information of each contender to allocate
* the highest ticket number for this cpu.
*/
- for (they = 0; they < BAKERY_LOCK_MAX_CPUS; they++) {
+ for (they = 0U; they < BAKERY_LOCK_MAX_CPUS; they++) {
if (me == they)
continue;
* ensure that a stale copy is not read.
*/
their_bakery_info = get_bakery_info(they, lock);
- assert(their_bakery_info);
+ assert(their_bakery_info != NULL);
- read_cache_op(their_bakery_info, is_cached);
+ read_cache_op((uintptr_t)their_bakery_info, is_cached);
/*
* Update this cpu's ticket number if a higher ticket number is
++my_ticket;
my_bakery_info->lock_data = make_bakery_data(CHOSEN_TICKET, my_ticket);
- write_cache_op(my_bakery_info, is_cached);
+ write_cache_op((uintptr_t)my_bakery_info, is_cached);
return my_ticket;
}
* Now that we got our ticket, compute our priority value, then compare
* with that of others, and proceed to acquire the lock
*/
- my_prio = PRIORITY(my_ticket, me);
- for (they = 0; they < BAKERY_LOCK_MAX_CPUS; they++) {
+ my_prio = bakery_get_priority(my_ticket, me);
+ for (they = 0U; they < BAKERY_LOCK_MAX_CPUS; they++) {
if (me == they)
continue;
* ensure that a stale copy is not read.
*/
their_bakery_info = get_bakery_info(they, lock);
- assert(their_bakery_info);
+ assert(their_bakery_info != NULL);
/* Wait for the contender to get their ticket */
do {
- read_cache_op(their_bakery_info, is_cached);
+ read_cache_op((uintptr_t)their_bakery_info, is_cached);
their_bakery_data = their_bakery_info->lock_data;
} while (bakery_is_choosing(their_bakery_data));
* (valid) ticket value. If they do, compare priorities
*/
their_ticket = bakery_ticket_number(their_bakery_data);
- if (their_ticket && (PRIORITY(their_ticket, they) < my_prio)) {
+ if (their_ticket && (bakery_get_priority(their_ticket, they) < my_prio)) {
/*
* They have higher priority (lower value). Wait for
* their ticket value to change (either release the lock
*/
do {
wfe();
- read_cache_op(their_bakery_info, is_cached);
+ read_cache_op((uintptr_t)their_bakery_info, is_cached);
} while (their_ticket
== bakery_ticket_number(their_bakery_info->lock_data));
}
* Then signal other waiting contenders.
*/
dmbst();
- my_bakery_info->lock_data = 0;
- write_cache_op(my_bakery_info, is_cached);
+ my_bakery_info->lock_data = 0U;
+ write_cache_op((uintptr_t)my_bakery_info, is_cached);
sev();
}
projects / project / bcm63xx / atf.git / commitdiff